import jwt from 'jsonwebtoken';
import bcrypt from 'bcryptjs';
import { NextRequest, NextResponse } from 'next/server';
import { query } from '@/utils/db';
import { RowDataPacket } from 'mysql2/promise';

// 定义Token的有效载荷类型
export interface TokenPayload {
  id: number;
  username: string;
  [key: string]: any;
}

// 确保有一个安全的JWT密钥
// 如果环境变量中没有设置，使用一个默认的密钥
// 注意：在生产环境中应该设置一个强密钥
// 这里使用一个足够长的默认密钥以确保安全性
const JWT_SECRET = process.env.JWT_SECRET || 'xiaoyoubao_default_jwt_secret_key_please_change_in_production_environment_2023';
const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN || '30d'; // 增加令牌有效期

// 生成JWT令牌
export const generateToken = (payload: TokenPayload): string => {
  try {
    console.log('正在生成令牌，密钥长度:', JWT_SECRET.length);
    console.log('使用的过期时间:', JWT_EXPIRES_IN);

    // 确保载荷中有必要的字段
    if (!payload.id || !payload.username) {
      throw new Error('令牌载荷缺少必要字段');
    }

    // 使用标准的jwt.sign方法
    // @ts-ignore - 类型定义问题
    const token = jwt.sign(payload, JWT_SECRET, {
      expiresIn: JWT_EXPIRES_IN,
      algorithm: 'HS256' // 明确指定算法
    });

    return token;
  } catch (error) {
    console.error('JWT签名错误:', error);
    throw error;
  }
};

// 验证JWT令牌
export const verifyToken = (token: string): TokenPayload | null => {
  try {
    console.log('正在验证令牌，令牌长度:', token.length);
    console.log('令牌前20个字符:', token.substring(0, 20) + '...');

    // 使用标准的jwt.verify方法
    // @ts-ignore - 类型定义问题
    const decoded = jwt.verify(token, JWT_SECRET, {
      algorithms: ['HS256'] // 明确指定算法
    }) as TokenPayload;

    console.log('令牌验证成功，用户ID:', decoded.id);
    return decoded;
  } catch (error) {
    console.error('JWT验证错误:', error);
    return null;
  }
};

// 密码加密
export const hashPassword = async (password: string): Promise<string> => {
  try {
    const salt = await bcrypt.genSalt(10);
    return bcrypt.hash(password, salt);
  } catch (error) {
    console.error('密码加密错误:', error);
    throw error;
  }
};

// 密码验证
export const comparePassword = async (
  password: string,
  hashedPassword: string
): Promise<boolean> => {
  try {
    return bcrypt.compare(password, hashedPassword);
  } catch (error) {
    console.error('密码比较错误:', error);
    throw error;
  }
};

interface AuthResult {
  isAuthenticated: boolean;
  user?: any;
  error?: string;
}

export async function verifyAuth(req: NextRequest): Promise<AuthResult> {
  try {
    // 从 Authorization 头中获取 token
    const authHeader = req.headers.get('Authorization');
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      return { isAuthenticated: false, error: '未提供有效的授权令牌' };
    }

    const token = authHeader.split(' ')[1];
    if (!token) {
      return { isAuthenticated: false, error: '授权令牌无效' };
    }

    // 验证 token
    const decoded = jwt.verify(token, JWT_SECRET) as { id: number };
    if (!decoded || !decoded.id) {
      return { isAuthenticated: false, error: '令牌解析失败' };
    }

    // 从数据库获取用户信息
    const userQuery = `
      SELECT 
        u.id, 
        u.username, 
        u.email,
        u.avatar,
        u.is_company_admin,
        c.id as company_id,
        c.name as company_name
      FROM users u
      LEFT JOIN companies c ON u.id = c.admin_user_id
      WHERE u.id = ?
    `;
    
    const [userResults] = await query<RowDataPacket[]>(userQuery, [decoded.id]);
    
    if (!userResults || userResults.length === 0) {
      return { isAuthenticated: false, error: '找不到用户' };
    }

    // 使用数组的第一个元素
    const userResult = userResults[0];

    return {
      isAuthenticated: true,
      user: userResult
    };
  } catch (error) {
    console.error('认证错误:', error);
    return { isAuthenticated: false, error: '认证失败' };
  }
}

// 身份验证中间件
export const authMiddleware = async (req: NextRequest): Promise<TokenPayload | NextResponse> => {
  try {
    const authHeader = req.headers.get('authorization');
    console.log('收到的授权头:', authHeader ? '存在' : '不存在');

    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      console.error('授权头不存在或格式不正确');
      return NextResponse.json({ error: '未授权' }, { status: 401 });
    }

    const token = authHeader.split(' ')[1];
    console.log('提取的令牌长度:', token.length);

    // 尝试验证令牌
    const decoded = verifyToken(token);

    if (!decoded) {
      console.error('令牌验证失败');
      return NextResponse.json({ error: '无效的令牌' }, { status: 401 });
    }

    console.log('身份验证成功，用户ID:', decoded.id);
    return decoded;
  } catch (error) {
    console.error('Auth middleware error:', error);
    return NextResponse.json({ error: '身份验证失败' }, { status: 401 });
  }
};